Integrationstestning: Bemästra API-testning med Supertest

Inom mjukvaruutveckling är det avgörande att säkerställa att enskilda komponenter fungerar korrekt isolerat (enhetstestning). Men det är lika viktigt att verifiera att dessa komponenter fungerar sömlöst tillsammans. Det är här integrationstestning kommer in i bilden. Integrationstestning fokuserar på att validera interaktionen mellan olika moduler eller tjänster i en applikation. Den här artikeln dyker djupt ner i integrationstestning, med särskilt fokus på API-testning med Supertest, ett kraftfullt och användarvänligt bibliotek för att testa HTTP-assertions i Node.js.

Vad är integrationstestning?

Integrationstestning är en typ av mjukvarutestning som kombinerar enskilda mjukvarumoduler och testar dem som en grupp. Syftet är att avslöja defekter i interaktionerna mellan integrerade enheter. Till skillnad från enhetstestning, som fokuserar på enskilda komponenter, verifierar integrationstestning dataflödet och kontrollflödet mellan moduler. Vanliga metoder för integrationstestning inkluderar:

• Top-down-integration: Börjar med modulerna på högsta nivån och integrerar nedåt.
• Bottom-up-integration: Börjar med modulerna på lägsta nivån och integrerar uppåt.
• Big-bang-integration: Integrerar alla moduler samtidigt. Denna metod rekommenderas generellt inte på grund av svårigheten att isolera problem.
• Sandwich-integration: En kombination av top-down- och bottom-up-integration.

I samband med API:er innebär integrationstestning att verifiera att olika API:er fungerar korrekt tillsammans, att data som skickas mellan dem är konsekvent och att systemet som helhet fungerar som förväntat. Föreställ dig till exempel en e-handelsapplikation med separata API:er för produkthantering, användarautentisering och betalningshantering. Integrationstestning skulle säkerställa att dessa API:er kommunicerar korrekt, vilket gör det möjligt för användare att bläddra bland produkter, logga in säkert och slutföra köp.

Varför är API-integrationstestning viktigt?

API-integrationstestning är avgörande av flera anledningar:

• Säkerställer systemets tillförlitlighet: Det hjälper till att identifiera integrationsproblem tidigt i utvecklingscykeln, vilket förhindrar oväntade fel i produktionen.
• Validerar dataintegritet: Det verifierar att data överförs och omvandlas korrekt mellan olika API:er.
• Förbättrar applikationens prestanda: Det kan avslöja prestandaflaskhalsar relaterade till API-interaktioner.
• Förbättrar säkerheten: Det kan identifiera säkerhetssårbarheter som uppstår från felaktig API-integration. Till exempel att säkerställa korrekt autentisering och auktorisering när API:er kommunicerar.
• Minskar utvecklingskostnader: Att åtgärda integrationsproblem tidigt är betydligt billigare än att hantera dem senare i utvecklingslivscykeln.

Tänk på en global plattform för resebokningar. API-integrationstestning är av yttersta vikt för att säkerställa smidig kommunikation mellan API:er som hanterar flygreservationer, hotellbokningar och betalningsgateways från olika länder. Om dessa API:er inte integreras korrekt kan det leda till felaktiga bokningar, betalningsmisslyckanden och en dålig användarupplevelse, vilket negativt påverkar plattformens rykte och intäkter.

Introduktion till Supertest: Ett kraftfullt verktyg för API-testning

Supertest är en abstraktion på hög nivå för att testa HTTP-anrop. Det erbjuder ett bekvämt och flytande API för att skicka förfrågningar till din applikation och göra assertions på svaren. Supertest är byggt ovanpå Node.js och är specifikt utformat för att testa Node.js HTTP-servrar. Det fungerar exceptionellt bra med populära testramverk som Jest och Mocha.

Nyckelfunktioner i Supertest:

• Lätt att använda: Supertest erbjuder ett enkelt och intuitivt API för att skicka HTTP-förfrågningar och göra assertions.
• Asynkron testning: Det hanterar sömlöst asynkrona operationer, vilket gör det idealiskt för att testa API:er som bygger på asynkron logik.
• Flytande gränssnitt: Det erbjuder ett flytande gränssnitt, vilket gör att du kan kedja metoder för koncis och läsbar testkod.
• Omfattande stöd för assertions: Det stöder ett brett utbud av assertions för att verifiera svarsstatuskoder, headers och body.
• Integration med testramverk: Det integreras sömlöst med populära testramverk som Jest och Mocha, vilket gör att du kan använda din befintliga testinfrastruktur.

Konfigurera din testmiljö

Innan vi börjar, låt oss sätta upp en grundläggande testmiljö. Vi antar att du har Node.js och npm (eller yarn) installerat. Vi kommer att använda Jest som vårt testramverk och Supertest för API-testning.

1. Skapa ett Node.js-projekt:

            mkdir api-testing-example
cd api-testing-example
npm init -y
            

              
                Copy
              
            
          

2. Installera beroenden:

            npm install --save-dev jest supertest
npm install express  # Eller ditt föredragna ramverk för att skapa API:et
            

              
                Copy
              
            
          

3. Konfigurera Jest: Lägg till följande i din package.json-fil:

            {
  "scripts": {
    "test": "jest"
  }
}
            

              
                Copy
              
            
          

4. Skapa en enkel API-endpoint: Skapa en fil med namnet app.js (eller liknande) med följande kod:

            const express = require('express');
const app = express();
const port = 3000;

app.get('/hello', (req, res) => {
  res.send('Hello, World!');
});

app.listen(port, () => {
  console.log(`Example app listening at http://localhost:${port}`);
});

module.exports = app; // Exportera för testning

            

              
                Copy
              
            
          

Skriva ditt första Supertest-test

Nu när vi har vår miljö konfigurerad, låt oss skriva ett enkelt Supertest-test för att verifiera vår API-endpoint. Skapa en fil med namnet app.test.js (eller liknande) i roten av ditt projekt:

            const request = require('supertest');
const app = require('./app');

describe('GET /hello', () => {
  it('responds with 200 OK and returns "Hello, World!"', async () => {
    const response = await request(app).get('/hello');
    expect(response.statusCode).toBe(200);
    expect(response.text).toBe('Hello, World!');
  });
});

            

              
                Copy
              
            
          

Förklaring:

• Vi importerar supertest och vår Express-app.
• Vi använder describe för att gruppera våra tester.
• Vi använder it för att definiera ett specifikt testfall.
• Vi använder request(app) för att skapa en Supertest-agent som kommer att göra anrop till vår app.
• Vi använder .get('/hello') för att skicka ett GET-anrop till /hello-endpointen.
• Vi använder await för att vänta på svaret. Supertests metoder returnerar promises, vilket gör att vi kan använda async/await för renare kod.
• Vi använder expect(response.statusCode).toBe(200) för att försäkra oss om att svarsstatuskoden är 200 OK.
• Vi använder expect(response.text).toBe('Hello, World!') för att försäkra oss om att svarskroppen (body) är "Hello, World!".

För att köra testet, kör följande kommando i din terminal:

            npm test
            

              
                Copy
              
            
          

Om allt är korrekt konfigurerat bör du se att testet passerar.

Avancerade Supertest-tekniker

Supertest erbjuder ett brett utbud av funktioner för avancerad API-testning. Låt oss utforska några av dem.

1. Skicka data i anropets body

För att skicka data i anropets body (request body) kan du använda metoden .send(). Låt oss till exempel skapa en endpoint som accepterar JSON-data:

            app.post('/users', express.json(), (req, res) => {
  const { name, email } = req.body;
  // Simulera att skapa en användare i en databas
  const user = { id: Date.now(), name, email };
  res.status(201).json(user);
});
            

              
                Copy
              
            
          

Så här kan du testa denna endpoint med Supertest:

            describe('POST /users', () => {
  it('creates a new user', async () => {
    const userData = {
      name: 'John Doe',
      email: 'john.doe@example.com',
    };

    const response = await request(app)
      .post('/users')
      .send(userData)
      .expect(201);

    expect(response.body).toHaveProperty('id');
    expect(response.body.name).toBe(userData.name);
    expect(response.body.email).toBe(userData.email);
  });
});
            

              
                Copy
              
            
          

Förklaring:

• Vi använder .post('/users') för att skicka ett POST-anrop till /users-endpointen.
• Vi använder .send(userData) för att skicka userData-objektet i anropets body. Supertest sätter automatiskt Content-Type-headern till application/json.
• Vi använder .expect(201) för att försäkra oss om att svarsstatuskoden är 201 Created.
• Vi använder expect(response.body).toHaveProperty('id') för att försäkra oss om att svarskroppen innehåller en id-egenskap.
• Vi använder expect(response.body.name).toBe(userData.name) och expect(response.body.email).toBe(userData.email) för att försäkra oss om att name- och email-egenskaperna i svarskroppen matchar den data vi skickade i anropet.

2. Sätta headers

För att sätta anpassade headers i dina anrop kan du använda metoden .set(). Detta är användbart för att sätta autentiseringstokens, content types eller andra anpassade headers.

            describe('GET /protected', () => {
  it('requires authentication', async () => {
    const response = await request(app).get('/protected').expect(401);
  });

  it('returns 200 OK with a valid token', async () => {
    // Simulera att hämta en giltig token
    const token = 'valid-token';

    const response = await request(app)
      .get('/protected')
      .set('Authorization', `Bearer ${token}`)
      .expect(200);

    expect(response.text).toBe('Protected Resource');
  });
});
            

              
                Copy
              
            
          

Förklaring:

• Vi använder .set('Authorization', `Bearer ${token}`) för att sätta Authorization-headern till Bearer ${token}.

3. Hantera cookies

Supertest kan också hantera cookies. Du kan sätta cookies med metoden .set('Cookie', ...), eller så kan du använda egenskapen .cookies för att komma åt och ändra cookies.

4. Testa filuppladdningar

Supertest kan användas för att testa API-endpoints som hanterar filuppladdningar. Du kan använda metoden .attach() för att bifoga filer till anropet.

5. Använda assertions-bibliotek (Chai)

Även om Jests inbyggda assertions-bibliotek är tillräckligt i många fall, kan du också använda kraftfullare assertions-bibliotek som Chai med Supertest. Chai erbjuder en mer uttrycksfull och flexibel syntax för assertions. För att använda Chai måste du installera det:

            npm install --save-dev chai
            

              
                Copy
              
            
          

Sedan kan du importera Chai i din testfil och använda dess assertions:

            const request = require('supertest');
const app = require('./app');
const chai = require('chai');
const expect = chai.expect;

describe('GET /hello', () => {
  it('responds with 200 OK and returns "Hello, World!"', async () => {
    const response = await request(app).get('/hello');
    expect(response.statusCode).to.equal(200);
    expect(response.text).to.equal('Hello, World!');
  });
});
            

              
                Copy
              
            
          

Observera: Du kan behöva konfigurera Jest för att fungera korrekt med Chai. Detta innebär ofta att man lägger till en setup-fil som importerar Chai och konfigurerar det att fungera med Jests globala expect.

6. Återanvända agenter

För tester som kräver att en specifik miljö sätts upp (t.ex. autentisering) är det ofta fördelaktigt att återanvända en Supertest-agent. Detta undviker redundant setup-kod i varje testfall.

            describe('Authenticated API Tests', () => {
  let agent;

  beforeAll(() => {
    agent = request.agent(app); // Skapa en beständig agent
    // Simulera autentisering
    return agent
      .post('/login')
      .send({ username: 'testuser', password: 'password123' });
  });

  it('can access a protected resource', async () => {
    const response = await agent.get('/protected').expect(200);
    expect(response.text).toBe('Protected Resource');
  });

  it('can perform other actions that require authentication', async () => {
    // Utför andra autentiserade åtgärder här
  });
});
            

              
                Copy
              
            
          

I detta exempel skapar vi en Supertest-agent i beforeAll-hooken och autentiserar agenten. Efterföljande tester inom describe-blocket kan sedan återanvända denna autentiserade agent utan att behöva autentisera på nytt för varje test.

Bästa praxis för API-integrationstestning med Supertest

För att säkerställa effektiv API-integrationstestning, överväg följande bästa praxis:

• Testa end-to-end-arbetsflöden: Fokusera på att testa kompletta användarflöden istället för isolerade API-endpoints. Detta hjälper till att identifiera integrationsproblem som kanske inte är uppenbara när man testar enskilda API:er isolerat.
• Använd realistisk data: Använd realistisk data i dina tester för att simulera verkliga scenarier. Detta inkluderar att använda giltiga dataformat, gränsvärden och potentiellt ogiltig data för att testa felhantering.
• Isolera dina tester: Se till att dina tester är oberoende av varandra och att de inte förlitar sig på delat tillstånd. Detta gör dina tester mer tillförlitliga och lättare att felsöka. Överväg att använda en dedikerad testdatabas eller att mocka externa beroenden.
• Mocka externa beroenden: Använd mockning för att isolera ditt API från externa beroenden, såsom databaser, tredjeparts-API:er eller andra tjänster. Detta gör dina tester snabbare och mer tillförlitliga, och det gör det också möjligt för dig att testa olika scenarier utan att förlita dig på tillgängligheten av externa tjänster. Bibliotek som nock är användbara för att mocka HTTP-anrop.
• Skriv omfattande tester: Sträva efter omfattande testtäckning, inklusive positiva tester (verifierar framgångsrika svar), negativa tester (verifierar felhantering) och gränsvärdestester (verifierar kantfall).
• Automatisera dina tester: Integrera dina API-integrationstester i din pipeline för kontinuerlig integration (CI) för att säkerställa att de körs automatiskt när ändringar görs i kodbasen. Detta hjälper till att identifiera integrationsproblem tidigt och förhindra att de når produktion.
• Dokumentera dina tester: Dokumentera dina API-integrationstester tydligt och koncist. Detta gör det lättare för andra utvecklare att förstå syftet med testerna och att underhålla dem över tid.
• Använd miljövariabler: Lagra känslig information som API-nycklar, databaslösenord och andra konfigurationsvärden i miljövariabler istället för att hårdkoda dem i dina tester. Detta gör dina tester säkrare och lättare att konfigurera för olika miljöer.
• Överväg API-kontrakt: Använd API-kontraktstestning för att validera att ditt API följer ett definierat kontrakt (t.ex. OpenAPI/Swagger). Detta hjälper till att säkerställa kompatibilitet mellan olika tjänster och förhindrar breaking changes. Verktyg som Pact kan användas för kontraktstestning.

Vanliga misstag att undvika

• Att inte isolera tester: Tester bör vara oberoende. Undvik att förlita dig på resultatet från andra tester.
• Att testa implementationsdetaljer: Fokusera på API:ets beteende och kontrakt, inte dess interna implementation.
• Att ignorera felhantering: Testa noggrant hur ditt API hanterar ogiltig input, kantfall och oväntade fel.
• Att hoppa över autentiserings- och auktoriseringstestning: Se till att ditt API:s säkerhetsmekanismer är ordentligt testade för att förhindra obehörig åtkomst.

Slutsats

API-integrationstestning är en väsentlig del av mjukvaruutvecklingsprocessen. Genom att använda Supertest kan du enkelt skriva omfattande och tillförlitliga API-integrationstester som hjälper till att säkerställa kvaliteten och stabiliteten i din applikation. Kom ihåg att fokusera på att testa end-to-end-arbetsflöden, använda realistisk data, isolera dina tester och automatisera din testprocess. Genom att följa dessa bästa praxis kan du avsevärt minska risken för integrationsproblem och leverera en mer robust och tillförlitlig produkt.

I takt med att API:er fortsätter att driva moderna applikationer och mikrotjänstarkitekturer, kommer vikten av robust API-testning, och särskilt integrationstestning, bara att fortsätta växa. Supertest erbjuder en kraftfull och tillgänglig verktygslåda för utvecklare över hela världen för att säkerställa tillförlitligheten och kvaliteten på deras API-interaktioner.